﻿//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using System.Runtime.Remoting;
//using System.Threading;
//using System.Collections;

//namespace Mbs.Messaging.Remoting
//{
//    [Serializable]
//    public partial class MessageBusProxy : MarshalByRefObject, IMessageBus
//    {
//        private IRemoteMessageBus Proxy;

//        public MessageBusProxy(string fileName, bool ensureSecurity, string remoteUrl)
//        {
//            RemotingConfiguration.Configure(fileName, false);
//            Proxy = Activator.GetObject(typeof(IRemoteMessageBus), remoteUrl) as IRemoteMessageBus;
//        }

       
//        #region IMessageBus Members

//        public void Publish<TMessage>(TMessage message)
//        {
//            Future.Create(() => Proxy.Publish<TMessage>(message));
//        }

//        public void Publish<TMessage>(object sender, TMessage message)
//        {
//            Future.Create(() => Proxy.Publish<TMessage>(sender, message)); 
//        }

//        public void Publish(string topic, object sender, object msg)
//        {
//            Future.Create(() => Proxy.Publish(topic, sender, msg));
//        }

//        public void Publish<TMessage>(string topic, TMessage message)
//        {
//            Future.Create(() => Proxy.Publish<TMessage>(topic, message));
//        }

//        public void Publish<TMessage>(string topic, object sender, TMessage message)
//        {
//            Future.Create(() => Proxy.Publish<TMessage>(topic,sender, message));
//        }

//        public IDisposable Subscribe<TMessage>(ObserverHandler<TMessage> handler)
//        {
//            var item = ProxyHandler<TMessage>(handler);
//            return new FutureDispose(Future.Create(() => Proxy.Subscribe<TMessage>(item)));
//        }

//        public IDisposable Subscribe<TMessage>(string topic, ObserverHandler<Topic<TMessage>> handler)
//        {
//            return new FutureDispose(Future.Create(() => Proxy.Subscribe<TMessage>(topic, ProxyHandler<Topic<TMessage>>(handler))));
//        }

//        public void Unsubscribe<TMessage>(ObserverHandler<TMessage> handler)
//        {
//            Future.Create(() => Proxy.Unsubscribe<TMessage>(ProxyHandler<TMessage>(handler)));
//        }

//        public void Unsubscribe<TMessage>(string topic, ObserverHandler<Topic<TMessage>> handler)
//        {
//            Future.Create(() => Proxy.Unsubscribe<TMessage>(topic, ProxyHandler<Topic<TMessage>>(handler)));
//        }

//        public IDisposable SubscribePreFilter<TMessage>(PreFilterHandler<TMessage> handler)
//        {
//            return new FutureDispose(Future.Create(() => Proxy.SubscribePreFilter<TMessage>(ProxyHandler<TMessage>(handler))));
//        }

//        public IDisposable SubscribePreFilter<TMessage>(string topic, PreFilterHandler<Topic<TMessage>> handler)
//        {
//            return new FutureDispose(Future.Create(() => Proxy.SubscribePreFilter<TMessage>(topic, ProxyHandler<Topic<TMessage>>(handler))));
//        }

//        public void UnsubscribePreFilter<TMessage>(PreFilterHandler<TMessage> handler)
//        {
//            Future.Create(() => Proxy.UnsubscribePreFilter<TMessage>(ProxyHandler<TMessage>(handler)));
//        }

//        public void UnsubscribePreFilter<TMessage>(string topic, PreFilterHandler<Topic<TMessage>> handler)
//        {
//            Future.Create(() => Proxy.UnsubscribePreFilter<TMessage>(topic, ProxyHandler<Topic<TMessage>>(handler)));
//        }

//        public IDisposable SubscribeFilter<TMessage>(FilterHandler<TMessage> handler)
//        {
//            return new FutureDispose(Future.Create(() => Proxy.SubscribeFilter<TMessage>(ProxyHandler<TMessage>(handler))));
//        }

//        public IDisposable SubscribeFilter<TMessage>(string topic, FilterHandler<Topic<TMessage>> handler)
//        {
//            return new FutureDispose(Future.Create(() => Proxy.SubscribeFilter<TMessage>(topic, ProxyHandler<Topic<TMessage>>(handler))));
//        }

//        public void UnsubscribeFilter<TMessage>(FilterHandler<TMessage> handler)
//        {
//            Future.Create(() => Proxy.UnsubscribeFilter<TMessage>(ProxyHandler<TMessage>(handler)));
//        }

//        public void UnsubscribeFilter<TMessage>(string topic, FilterHandler<Topic<TMessage>> handler)
//        {
//            Future.Create(() => Proxy.UnsubscribeFilter<TMessage>(topic, ProxyHandler<Topic<TMessage>>(handler)));
//        }

//        public void RegisterListner(params ISimpleMessageListner[] hks)
//        {
//            Future.Create(()=> Proxy.RegisterListner(hks));
//        }

//        public void UnRegisterListner(params ISimpleMessageListner[] hks)
//        {
//            Future.Create(() => Proxy.UnRegisterListner(hks));
//        }

//        public void Remove<TMessage>()
//        {
//            Future.Create(() => Proxy.Remove<TMessage>());
//        }

//        public void Remove<TMessage>(string topic)
//        {
//            Future.Create(() => Proxy.Remove<TMessage>(topic));
//        }

//        public void Remove(Type type)
//        {
//            Future.Create(() => Proxy.Remove(type));
//        }

//        public void Remove(string topic, Type type)
//        {
//            Future.Create(() => Proxy.Remove(topic,type));
//        }

//        #endregion

//        #region IPublisher Members

//        public void Publish(object sender, object msg)
//        {
//            Future.Create(()=>Proxy.Publish(sender, msg));
//        }

//        #endregion

//        #region IDisposable Members

//        public void Dispose()
//        {
//            Future.Create(() => Proxy.Dispose());
//        }

//        #endregion
//    }

//    public partial class MessageBusProxy
//    {
//        [Serializable]
//        class ObserverHandlerWrapper<TMessage> : MarshalByRefObject, IObserverHandler<TMessage>
//        {
//            private ObserverHandler<TMessage> localHandler;
//            public ObserverHandlerWrapper(ObserverHandler<TMessage> handler)
//            {
//                localHandler = handler;
//            }

//            public void Invoke(object sender, TMessage e)
//            {
//                if (localHandler != null)
//                    localHandler.Post(sender, e);
//            }

//            public override object InitializeLifetimeService()
//            {
//                return null;
//            }
//        }

//        [Serializable]
//        class FilterHandlerWrapper<TMessage> : MarshalByRefObject, IFilterHandler<TMessage>
//        {
//            private FilterHandler<TMessage> localHandler;
//            public FilterHandlerWrapper(FilterHandler<TMessage> handler)
//            {
//                localHandler = handler;
//            }

//            public void Invoke(object sender, FilterEventArgs<TMessage> e)
//            {
//                if (localHandler != null)
//                    localHandler.Post(sender, e);
//            }

//            public override object InitializeLifetimeService()
//            {
//                return null;
//            }
//        }

//        [Serializable]
//        class PreFilterHandlerWrapper<TMessage> : MarshalByRefObject, IPreFilterHandler<TMessage>
//        {
//            private PreFilterHandler<TMessage> localHandler;
//            public PreFilterHandlerWrapper(PreFilterHandler<TMessage> handler)
//            {
//                localHandler = handler;
//            }

//            public void Invoke(object sender, PreFilterEventArgs<TMessage> e)
//            {
//                if (localHandler != null)
//                    localHandler.Post(sender, e);
//            }

//            public override object InitializeLifetimeService()
//            {
//                return null;
//            }
//        }

//        private IObserverHandler<TMessage> ProxyHandler<TMessage>(ObserverHandler<TMessage> handler)
//        {
//            var item = new ObserverHandlerWrapper<TMessage>(handler);
//            return item;
//        }

//        private IPreFilterHandler<TMessage> ProxyHandler<TMessage>(PreFilterHandler<TMessage> handler)
//        {
//            var item = new PreFilterHandlerWrapper<TMessage>(handler);
//            return item;
//        }

//        private IFilterHandler<TMessage> ProxyHandler<TMessage>(FilterHandler<TMessage> handler)
//        {
//            return new FilterHandlerWrapper<TMessage>(handler);
//        }

//        //private class FutureDispose : IDisposable
//        //{
//        //    private IFuture<IDisposable> Future;
//        //    public FutureDispose(IFuture<IDisposable> value)
//        //    {
//        //        Future = value;
//        //    }

//        //    public void Dispose()
//        //    {
//        //        if (Future != null)
//        //        {
//        //            if (!Future.IsCompleted)
//        //            {
//        //                Future.Wait(1000);
//        //                Future.Value.Dispose();
//        //            }
//        //        }
//        //    }
//        //}

//    }
//}
